package Brute_Force;

import java.util.HashMap;
import java.util.Map;

public class leecode01 {

        public int[] twoSum(int[] nums, int target) {
            Map<Integer,Integer> map = new HashMap<>();
//            不能使用HashMap<Integer,Integer>(),而是Hashmap<>()
            for (int i = 0; i < nums.length; i++) {
                int complete=target-nums[i];
                if (map.containsKey(complete)){
//                    这里不能使用containsValue(),而是containsKey()
                    return new int[]{map.get(complete),i};
                    //使用{},而不是()
                    //返回索引
                }
                map.put(nums[i],i);
//                如果颠倒为 map.put(i, nums[i])：
//                键变成了索引，值变成了数组元素
//                我们无法通过 complete（目标值）来查找到对应的索引
//                因为 complete 是值，不是索引，无法作为查找的键
//                让我用一个具体例子说明：
//                数组 [2, 7, 11, 15]，target = 9：
//                当 i=1 时，nums[i]=7，complete = 9-7 = 2
//                我们需要找到值为 2 的元素的索引
//                如果用 map.put(nums[i], i)，即 map.put(7, 1)，同时之前已存入 map.put(2, 0)
//                现在用 map.containsKey(2) 可以找到值为2的元素，通过 map.get(2) 得到索引0
//                返回结果 [0, 1] 正确
//                这就是为什么不能颠倒的原因。

            }
            return new int[]{};



        }
//    public int[] twoSum(int[] nums, int target) {
//        // 更好的方法是将元素值作为键，索引作为值存储
//        Map<Integer, Integer> map = new HashMap<>();
//        for (int i = 0; i < nums.length; i++) {
//            int complement = target - nums[i];
//            // 检查map中是否已经有我们需要的补数，并且确保不是当前元素本身
//            if (map.containsKey(complement)) {
//                return new int[]{map.get(complement), i};
//            }
//            // 将当前元素放入map中
//            map.put(nums[i], i);
//        }
//        return new int []{}; // 如果没有找到，返回空数组
//    }

    public static void main(String[] args) {
        leecode01 solution = new leecode01();

        // 测试用例1
        int[] nums1 = {2, 7, 11, 15};
        int target1 = 9;
        int[] result1 = solution.twoSum(nums1, target1);
        System.out.println("输入: nums = [2,7,11,15], target = 9");
        System.out.println("输出: [" + result1[0] + ", " + result1[1] + "]");
        System.out.println();

        // 测试用例2
        int[] nums2 = {3, 2, 4};
        int target2 = 6;
        int[] result2 = solution.twoSum(nums2, target2);
        System.out.println("输入: nums = [3,2,4], target = 6");
        System.out.println("输出: [" + result2[0] + ", " + result2[1] + "]");
        System.out.println();

        // 测试用例3
        int[] nums3 = {3, 3};
        int target3 = 6;
        int[] result3 = solution.twoSum(nums3, target3);
        System.out.println("输入: nums = [3,3], target = 6");
        System.out.println("输出: [" + result3[0] + ", " + result3[1] + "]");
    }
}
